package cn.kent.high.juc.lock.reentrantLock;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 *
 */
public class ReentrantLockNonfairTest {
    private static final ReentrantLock lock = new ReentrantLock();
    private static final Condition condition = lock.newCondition();

    public static void main(String[] args) {

        lock.lock();
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


        /**
         * 非公平锁加锁方法
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        // final void lock() {
        //     if (compareAndSetState(0, 1))//CAS设置状态
        //         setExclusiveOwnerThread(Thread.currentThread());
        //     else
        //         acquire(1); // 调用AQS的acquire方法
        // }
        //
        // public final void acquire(int arg) {
        //     if (!tryAcquire(arg) &&
        //             acquireQueued(addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE), arg))
        //         selfInterrupt();
        // }

        // 非公平锁方法 -> 添加到等待队列
        // private AbstractQueuedSynchronizer.Node addWaiter(AbstractQueuedSynchronizer.Node mode) {
        //     AbstractQueuedSynchronizer.Node node = new AbstractQueuedSynchronizer.Node(Thread.currentThread(), mode);
        //     // Try the fast path of enq; backup to full enq on failure
        //     AbstractQueuedSynchronizer.Node pred = tail;
        //     if (pred != null) {
        //         node.prev = pred;
        //         if (compareAndSetTail(pred, node)) { // 添加到尾节点
        //             pred.next = node;
        //             return node; // 添加成功则直接返回
        //         }
        //     }
        //     // 走到这一步的情况： 添加到尾结点失败 || tail == null-->AQS内部等待链表为空
        //     enq(node);
        //     return node;
        // }
        // /**
        //  * Inserts node into queue, initializing if necessary. See picture above.
        //  * @param node the node to insert
        //  * @return node's predecessor
        //  */
        // private AbstractQueuedSynchronizer.Node enq(final AbstractQueuedSynchronizer.Node node) {
        //     for (;;) {
        //         AbstractQueuedSynchronizer.Node t = tail;
        //         if (t == null) { // Must initialize -> 尾结点为空，链表为空，开始初始化链表
        //             if (compareAndSetHead(new AbstractQueuedSynchronizer.Node()))
        //                 tail = head;
        //         } else { // 这一步肯定是已经初始化好的链表了。
        //             node.prev = t; // 将当前尾结点设置为新尾结点的前置节点
        //             if (compareAndSetTail(t, node)) { // 要插入的节点（新尾结点）和老尾节点比对，成功则加到尾结点啦。
        //                 t.next = node;
        //                 return t;// 放回新增的节点，即加到的节点
        //             }
        //         }
        //     }
        // }

        // final boolean acquireQueued(final AbstractQueuedSynchronizer.Node node, int arg) {
        //     boolean failed = true;
        //     try {
        //         boolean interrupted = false;
        //         for (;;) {
        //             final AbstractQueuedSynchronizer.Node p = node.predecessor(); // 返回哨兵节点(尾结点的前节点)
        //             if (p == head && tryAcquire(arg)) {// p==head 说明队列中只有一个节点
        //                 setHead(node);
        //                 p.next = null; // help GC
        //                 failed = false;
        //                 return interrupted;
        //             }
        //             if (shouldParkAfterFailedAcquire(p, node) &&
        //                     parkAndCheckInterrupt())
        //                 interrupted = true;
        //         }
        //     } finally {
        //         if (failed)
        //             cancelAcquire(node);
        //     }
        // }
    }
}
